package com.ftg.learn.chapter07;

/**
 * 线程不安全的 可变字符序列
 * @author kangjx
 * @createTime 2022/12/29
 */
public class String05 {

    /**
     * 想像在为这个一个全局变量
     */
//    String05 this = new String05();

    /**
     * private 只有我自己能用
     */
    private int sum = 0;


    public int getSum() {
        return sum;
    }

    public String05 add(int e) {
        sum += e;
        /**
         * this :  表示表类的实例
         */
        return this;
    }

    public String05 div(int e){
        sum -= e;
        return this;
    }


    public static void main(String[] args) {

        String05 string05 = new String05();
        //像一个链子一样来完成对java的调用 链式..


        System.out.println(string05.add(23).add(4).add(5).add(6).div(6).add(7).getSum());

//        //大量重复写实例.
//        string05.add(23);
//        string05.add(34);
//        string05.add(67);
//        //链式 只有链式方法返回值是 是实例本身
//        System.out.println(string05.getSum());


        String s = "abc";
        s = "def";

        System.out.println(s + "java虚拟机里面的本地变量表");

//        s  最终是在常量池，存储两个字符串  "abc" "def"
        //如果你在开发，设计过程当中，大量对字符串进行了  添加 、修改 、二次赋值 占用空间

//        jdk :  可变字符序列  [里面大量 线性表 动态数组 changeArray]
        //Stringbuilder Stringbuffer

        //今天Stringbuilder

        //实例化一个下层阶级 （jvm会先实例化上层阶级）  -- 子的   构造  -  super(16);
        StringBuilder stringBuilder = new StringBuilder();
        //是一个可变的字符序列 ·「char数组」  这个数组默认长度为  16

        //底层也是数组，数组默认长度是多少?  (用友的面试原题  )  给定字符串字符数+ 16 ， 给定的字符串添加到数组里面
        StringBuilder stringBuilder1 = new StringBuilder("abcd");

        //java 链式访问 链式调用

        //常用方法
        /**
         * 追加方法 ：  表示在数组底层的后面添加数据 SS
         * char[] c = new char[16];
         * int count=0;
         * c[count++] = s;
         * c[count++] = s;
         */
        /**
         * 构造方法可以初始化数组 16   字符串+ 16
         *
         * append()不会初始化数组，扩容  扩容
         */
        stringBuilder.append("ss").append("t").append("x").append("y");
        System.out.println(stringBuilder);

        //Stringbuilder 默认16 append存储的时候 ，会产生扩容处理
        // 最大长度为   Integer.MAX_VALUE - 8
        // 最小长度为   16
        // 最小扩容     原长度  << 1 + 2
        // 最大扩容     原长度 + 新存储元素
        //1 : 默认 原长度 << 1 + 2  要与  原长度 + 新存储元素 个数 : 较大才是新值
        //2 : 如果计算出来的长度，过大 integer.max_value Array_size_ Integer.MAX_VALUE - 8
        //缩容.. append()
        stringBuilder.trimToSize();
        stringBuilder.append("x");

        StringBuilder builder01 = new StringBuilder();
//        builder01.appendCodePoint(67890);
//        System.out.println(builder01);

        //有大量关于可变字符串处理的方法
//        builder01
//                .delete(int start, int end)  [1,4] (1,4) [1,4) (1,4]
//                .deleteCharAt(int index) 索引 从0 删除某一个char

        builder01.append("abcdefg");

        //清除某一个索引 对应的char
//        builder01.deleteCharAt(1);
//        System.out.println(builder01);

        builder01.delete(0,5);
        System.out.println(builder01);

        //美团原题  : 会清除工作缓存?
        System.out.println();

        //这个为什么报错 ？
//        String abc = builder01.toString();

//        textOut.flushBuffer();
//        charOut.flushBuffer();
//        if (autoFlush)
//            out.flush();


//        在对一个引用类型，进行输出的时候 ，会调用这个类型的里面的toString()转换成为字符串，然后再打印出来

        //最坏 ·「最好」 2W 下标为0

        // 底层采用数组 ： 物理空间是连续， randomaccess {随机访问}\遍历速度.删除速度不快，插入速度也不快

        //insert  插入 [ 列表，添加、修改、删除 crud ]
//        builder01.insert(0,2L);

        builder01.insert(1,"abcefg",1,2);
        builder01.insert(1,builder01,1,2);

        //charsequeue 字符序列 interface 接口 里面没有代码实现，要求低级类完成这个功能.
        // 六大原则 ：  单一职责  开闭原则  里氏代替

        System.out.println(builder01);

        String s1 = String.valueOf(true);
        System.out.println(s1);

        //修改
        builder01.setCharAt(0,'c');

        builder01 = new StringBuilder("abcdefghijk");
        builder01.setLength(3);

        builder01.setLength(builder01.length());
        builder01.append("s");

        //产生新的地址
        builder01.trimToSize();
//        count = 3;
//        return new String(value, 0, count);

        System.out.println(builder01);

        //12321  从左向右   从右向左  回文数
        int a = 55;
        String astr = String.valueOf(a);

        StringBuilder s11 = new StringBuilder(astr);
        String s12 = s11.reverse().toString();

        System.out.println(astr.equals(s12) ? "是回文数":"一定不是");

        //string 不可变字符序列  对应的可变字符序列stringbuilder

    }

}
